const dayjs = require('dayjs');
/**
 * 研发项目分支管理模块
 * 负责处理研发项目的分支创建、查询、管理等功能
 */

// 引入辅助工具
const cloudHelper = require('./helpers/cloud_helper.js');
const pageHelper = require('./helpers/page_helper.js');
const timeHelper = require('./helpers/time_helper.js');

/**
 * 分支管理器类
 * 用于处理研发项目中的分支管理
 */
class BranchManager {
  /**
   * 构造函数
   * @param {Object} page - 页面实例
   * @param {Object} options - 配置选项
   */
  constructor(page, options = {}) {
    this.page = page;
    this.options = options;
    this.cacheTime = options.cacheTime || 5 * 60 * 1000; // 默认缓存5分钟
    this.cache = {};
  }

  /**
   * 获取项目分支列表
   * @param {string} projectId - 项目ID
   * @param {boolean} useCache - 是否使用缓存
   * @returns {Promise<Array>} 分支项目列表
   */
  async getBranchProjects(projectId, useCache = true) {
    if (!projectId) return [];
    
    // 检查缓存
    const cacheKey = `branch_projects_${projectId}`;
    if (useCache && this.cache[cacheKey] && (dayjs().valueOf() - this.cache[cacheKey].time < this.cacheTime)) {
      return this.cache[cacheKey].data;
    }
    
    try {
      const params = {
        parentId: projectId
      };
      
      const result = await cloudHelper.callCloudData('research/get_branch_projects', params);
      
      // 更新缓存
      if (result && Array.isArray(result)) {
        this.cache[cacheKey] = {
          time: dayjs().valueOf(),
          data: result
        };
      }
      
      return result || [];
    } catch (error) {
      console.error('获取项目分支列表失败', error);
      return [];
    }
  }

  /**
   * 创建分支项目
   * @param {Object} params - 分支创建参数
   * @returns {Promise<Object>} 创建结果
   */
  async createBranch(params) {
    if (!params || !params.parentId || !params.name) {
      throw new Error('分支创建参数不完整');
    }
    
    try {
      // 构建分支项目数据
      const branchData = {
        parentId: params.parentId,
        name: params.name,
        desc: params.desc || '',
        type: params.type || 'normal'
      };
      
      // 调用创建API
      const result = await cloudHelper.callCloudData('research/create_branch', branchData);
      
      // 清除缓存
      const cacheKey = `branch_projects_${params.parentId}`;
      if (this.cache[cacheKey]) {
        delete this.cache[cacheKey];
      }
      
      return result;
    } catch (error) {
      console.error('创建分支项目失败', error);
      throw error;
    }
  }

  /**
   * 获取分支树
   * @param {string} projectId - 项目ID
   * @returns {Promise<Object>} 分支树结构
   */
  async getBranchTree(projectId) {
    if (!projectId) return null;
    
    try {
      const params = {
        projectId: projectId
      };
      
      return await cloudHelper.callCloudData('research/get_branch_tree', params);
    } catch (error) {
      console.error('获取分支树失败', error);
      return null;
    }
  }

  /**
   * 切换当前分支
   * @param {string} branchId - 分支ID
   * @returns {Promise<boolean>} 是否切换成功
   */
  async switchBranch(branchId) {
    if (!branchId) return false;
    
    try {
      const params = {
        branchId: branchId
      };
      
      await cloudHelper.callCloudData('research/switch_branch', params);
      return true;
    } catch (error) {
      console.error('切换分支失败', error);
      pageHelper.showError('切换分支失败: ' + error.message);
      return false;
    }
  }

  /**
   * 查询父项目
   * @param {string} projectId - 项目ID
   * @returns {Promise<Object>} 父项目
   */
  async getParentProject(projectId) {
    if (!projectId) return null;
    
    try {
      const params = {
        projectId: projectId
      };
      
      return await cloudHelper.callCloudData('research/get_parent_project', params);
    } catch (error) {
      console.error('查询父项目失败', error);
      return null;
    }
  }

  /**
   * 合并分支
   * @param {string} sourceId - 源分支ID
   * @param {string} targetId - 目标分支ID
   * @returns {Promise<boolean>} 是否合并成功
   */
  async mergeBranch(sourceId, targetId) {
    if (!sourceId || !targetId) return false;
    
    try {
      const params = {
        sourceId: sourceId,
        targetId: targetId
      };
      
      await cloudHelper.callCloudData('research/merge_branch', params);
      
      // 清除缓存
      Object.keys(this.cache).forEach(key => {
        if (key.startsWith('branch_projects_')) {
          delete this.cache[key];
        }
      });
      
      return true;
    } catch (error) {
      console.error('合并分支失败', error);
      pageHelper.showError('合并分支失败: ' + error.message);
      return false;
    }
  }
}

module.exports = BranchManager; 